.TH std::function::function 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::function::function \- std::function::function

.SH Synopsis
   function() noexcept;                            \fB(1)\fP \fI(since C++11)\fP
   function( std::nullptr_t ) noexcept;            \fB(2)\fP \fI(since C++11)\fP
   function( const function& other );              \fB(3)\fP \fI(since C++11)\fP
   function( function&& other );                                     \fI(since C++11)\fP
                                                                     \fI(until C++20)\fP
   function( function&& other ) noexcept;                            \fI(since C++20)\fP
   template< class F >                                 \fB(5)\fP           \fI(since C++11)\fP
   function( F&& f );
   template< class Alloc >                                           \fI(since C++11)\fP
   function( std::allocator_arg_t, const Alloc&        \fB(6)\fP           (removed in C++17)
   alloc ) noexcept;
   template< class Alloc >

   function( std::allocator_arg_t, const Alloc&        \fB(7)\fP           \fI(since C++11)\fP
   alloc,                                                            (removed in C++17)

             std::nullptr_t ) noexcept;
   template< class Alloc >                         \fB(4)\fP

   function( std::allocator_arg_t, const Alloc&        \fB(8)\fP           \fI(since C++11)\fP
   alloc,                                                            (removed in C++17)

             const function& other );
   template< class Alloc >

   function( std::allocator_arg_t, const Alloc&        \fB(9)\fP           \fI(since C++11)\fP
   alloc,                                                            (removed in C++17)

             function&& other );
   template< class F, class Alloc >                                  \fI(since C++11)\fP
   function( std::allocator_arg_t, const Alloc&        \fB(10)\fP          (removed in C++17)
   alloc, F f );

   Constructs a std::function from a variety of sources.

   1,2) Creates an empty std::function.
   3) Copies the target of other to the target of *this.
   If other is empty, *this will be empty right after the call too.
   4) Moves the target of other to the target of *this.
   If other is empty, *this will be empty right after the call too.
   other is in a valid but unspecified state right after the call.
   5) Initializes the target with std::forward<F>(f). The target is of type
   std::decay<F>::type.
   If f is a null pointer to function, a null pointer to member, or an empty value of
   some std::function specialization, *this will be empty right after the call.
   This overload participates in overload resolution only if all following conditions
   are satisfied:

     * std::is_same_v<std::remove_cvref_t<F>, std::function<R(Args...)>   (since C++23)
       is false.

     * An lvalue of type std::decay<F>::type is callable for argument types Args... and
       return type R.

   If std::is_copy_constructible_v<std::decay_t<F>> or
   std::is_constructible_v<std::decay_t<F>, F> is false, the program is   (since C++23)
   ill-formed.

   If F is not CopyConstructible, the behavior is undefined.
   6-10) Same as (1-5) except that alloc is used to allocate memory for any internal
   data structures that the std::function might use.

   When the target is a function pointer or a std::reference_wrapper, small object
   optimization is guaranteed, that is, these targets are always directly stored inside
   the std::function object, no dynamic allocation takes place. Other large objects may
   be constructed in dynamic allocated storage and accessed by the std::function object
   through a pointer.

.SH Parameters

   other - the function object used to initialize *this
   f     - a callable object used to initialize *this
   alloc - an Allocator used for internal memory allocation
.SH Type requirements
   -
   Alloc must meet the requirements of Allocator.

.SH Exceptions

   3,8,9) Does not throw if other's target is a function pointer or a
   std::reference_wrapper, otherwise may throw std::bad_alloc or any exception thrown
   by the constructor used to copy or move the stored callable object.

   4) Does not throw if other's target is a function pointer or a
   std::reference_wrapper, otherwise may throw std::bad_alloc or any      \fI(until C++20)\fP
   exception thrown by the constructor used to copy or move the stored
   callable object.

   5,10) Does not throw if f is a function pointer or a std::reference_wrapper,
   otherwise may throw std::bad_alloc or any exception thrown by the copy constructor
   of the stored callable object.

.SH Notes

   std::function's allocator support was poorly specified and inconsistently
   implemented. Some implementations do not provide overloads (6-10) at all, some
   provide the overloads but ignore the supplied allocator argument, and some provide
   the overloads and use the supplied allocator for construction but not when the
   std::function is reassigned. As a result, allocator support was removed in C++17.

.SH Example

    This section is incomplete
    Reason: no example

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to        Behavior as published        Correct behavior
   LWG 2132 C++11      overloads (5,10) might be ambiguous constrained
   LWG 2774 C++11      (5,10) performed an additional move eliminated

.SH See also

   constructor   constructs a new std::move_only_function object
   (C++23)       \fI(public member function of std::move_only_function)\fP

.SH Category:
     * Todo no example
